
///////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2005, Perry L Miller IV
//  All rights reserved.
//  BSD License: http://www.opensource.org/licenses/bsd-license.html
//
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
//
//  Tree node class.
//
///////////////////////////////////////////////////////////////////////////////

#include "Tree/Node.h"

using namespace Tree;


///////////////////////////////////////////////////////////////////////////////
//
//  Constructor.
//
///////////////////////////////////////////////////////////////////////////////

Node::Node ( const std::string &name, const std::string &value ) : 
  BaseClass ( name ),
  _value      ( value ),
  _attributes (),
  _children   ()
{
}


///////////////////////////////////////////////////////////////////////////////
//
//  Destructor
//
///////////////////////////////////////////////////////////////////////////////

Node::~Node()
{
}


///////////////////////////////////////////////////////////////////////////////
//
//  Clear the document.
//
///////////////////////////////////////////////////////////////////////////////

void Node::clear()
{
  Guard guard ( this );
  _value.clear();
  _children.clear();
  _attributes.clear();
}


///////////////////////////////////////////////////////////////////////////////
//
//  Get children.
//
///////////////////////////////////////////////////////////////////////////////

Tree::Node::Children Node::children() const
{
  Guard guard ( this );
  return _children;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Get children.
//
///////////////////////////////////////////////////////////////////////////////

void Node::children ( const Children &c )
{
  Guard guard ( this );
  _children = c;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Get attributes.
//
///////////////////////////////////////////////////////////////////////////////

Node::Attributes Node::attributes() const
{
  Guard guard ( this );
  return _attributes;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Get attributes.
//
///////////////////////////////////////////////////////////////////////////////

void Node::attributes ( const Attributes &a )
{
  Guard guard ( this );
  _attributes = a;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Set value.
//
///////////////////////////////////////////////////////////////////////////////

void Node::value ( const std::string &v )
{
  Guard guard ( this );
  _value = v;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Get value.
//
///////////////////////////////////////////////////////////////////////////////

std::string Node::value() const
{
  Guard guard ( this );
  return _value;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Get the attribute. Returns empty string if it's not there.
//
///////////////////////////////////////////////////////////////////////////////

std::string Node::attribute ( const std::string &name ) const
{
  Guard guard ( this );
  Attributes::const_iterator i ( _attributes.find ( name ) );
  return ( ( _attributes.end() == i ) ? std::string() : i->second );
}


///////////////////////////////////////////////////////////////////////////////
//
//  Set the attribute.
//
///////////////////////////////////////////////////////////////////////////////

void Node::attribute ( const std::string &name, const std::string &value )
{
  if ( false == name.empty() )
  {
    Guard guard ( this );
    _attributes[name] = value;
  }
}


///////////////////////////////////////////////////////////////////////////////
//
//  Append the node.
//
///////////////////////////////////////////////////////////////////////////////

void Node::append ( Node::RefPtr node )
{
  if ( true == node.valid() )
  {
    Guard guard ( this );
    _children.push_back ( node );
  }
}


///////////////////////////////////////////////////////////////////////////////
//
//  Return number of children.
//
///////////////////////////////////////////////////////////////////////////////

unsigned int Node::numChildren() const
{
  Guard guard ( this );
  return _children.size();
}
